home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d12 / c_edit.arc / ED4.C < prev    next >
C/C++ Source or Header  |  1991-09-08  |  11KB  |  704 lines
  1. /* ED4.C */
  2.  
  3. #include "ed0.c"
  4. #include "ed1.ccc"
  5. char    editbuf[MAXLEN];
  6. char pickbuf[PUTBUFLN]; /* pick buffer */
  7. int picklines, pickend; /* pick buffer parameters */
  8. int    editp;
  9. int    editpmax;
  10. int    edcflag;
  11. edabt()
  12. {
  13.     edgetln();
  14.     edredraw();
  15.     edbegin();
  16.     edcflag=NO;
  17. }
  18. edbegin()
  19. {
  20.     editp=0;
  21.     outxy(0,outyget());
  22. }
  23. ederase()    /* new: erase from cursor to end of line */
  24. {
  25.     if (editp==editpmax) {
  26.         return;
  27.     }
  28.     edcflag=YES;
  29.     editpmax=editp;
  30.     edredraw();
  31. }
  32. edhome()    /* new: home cursor.  subsequent calls alternate */
  33. {        /* cursor to top and bottom of screen */
  34. int ypos;
  35.     if (edrepl()!=OK){
  36.         return;
  37.     }
  38.     if ((ypos=outyget())<SCRNL3) {
  39.         while((ypos<SCRNL1)&&(!bufnrbot())){
  40.             if (bufdn()!=OK){
  41.                 return(ERR);
  42.             }
  43.             ypos++;
  44.         }
  45.     }
  46.     else {
  47.         while((ypos>1)&&(!bufattop())){
  48.             if (bufup()!=OK){
  49.                 return(ERR);
  50.             }
  51.             ypos--;
  52.         }
  53.     }
  54.     edgetln();
  55.     outxy(edxpos(),ypos);
  56. }
  57. edpick(begin,end) int begin,end; {    /* pick marked lines to buffer */
  58. int oldline,oldx,oldy,len,nlines;
  59.     if ((begin==(-1))|(end==(-1))|(end<begin)){
  60.         sysabort();
  61.         return(ERR);
  62.         }
  63.     oldx=outxget();
  64.     oldy=outyget();
  65.     if (edrepl()!=OK) {
  66.         return(ERR);
  67.         }
  68.     oldline=bufln();
  69.     nlines=end-begin+1;
  70.     len=buflength(begin,nlines);
  71.     if (len>PUTBUFLN){
  72.         pmtmode("Not picked: no room");
  73.         sysabort();
  74.         return(ERR);
  75.         }
  76.     pickend=len;
  77.     buftopick(pickbuf,begin,nlines);
  78.     bufgo(oldline);
  79.     edgetln();
  80.     editp=edscan(oldx);
  81.     outxy(oldx,oldy);
  82.     edredraw();
  83.     picklines=nlines;
  84.     return(OK);
  85.     }
  86. edput() {        /* put lines in pick buffer into main buffer */
  87.             /* before current line */
  88. int k,oldline,oldx,oldy;
  89.     if (pickend==0){
  90.         return(OK);
  91.         }
  92.     oldx=outxget();
  93.     oldy=outyget();
  94.     if (edrepl()!=OK){
  95.         return(ERR);
  96.         }
  97.     oldline=bufln();
  98.     if (picktobuf(pickbuf,pickend,picklines)!=OK) {
  99.         return(ERR);
  100.         }
  101.     bufgo(oldline);
  102.     if (edatbot()){
  103.         ;
  104.     }
  105.     else{
  106.         bufout(bufln()+1,oldy+1,SCRNL1-oldy);
  107.         }
  108.     edgetln();
  109.     outxy(0,oldy);
  110.     edredraw();
  111.     editp=min(oldx,editpmax);
  112.     outxy(edxpos(),oldy);
  113.     return(OK);
  114.     }
  115. edchng(c) char c;
  116. {
  117. char oldc;
  118. int k,kk,n,m,tabpos;
  119.     if (editp>=editpmax) {
  120.         edins(c);
  121.         return;
  122.     }
  123. /* experimental code for better treatment of virtual columns */
  124.     if (editbuf[editp]==c) {
  125.         edright();
  126.         return;
  127.     }
  128.     tabpos=outxget()%tablength();
  129.     if ((editbuf[editp]==TAB)&(tabpos!=tablength()-1)) {
  130.         edins(c);
  131.         return;
  132.     }
  133.     kk=editp-1;
  134.     m=NO;
  135.     if ((kk>=0)&(editbuf[kk]==TAB)&(tabpos!=0)) {
  136.         editp--;
  137.         n=outxget()-edxpos();
  138.         if ((n+fmtlen(editbuf,editpmax)+1)<SCRNW1) {
  139.             k=editpmax;
  140.             while (k>(editp+1)) { 
  141.                 editbuf[k+n-1]=editbuf[k-1];
  142.                 k--;
  143.             }
  144.             while (n-- >0) {
  145.                 editbuf[editp++]=' ';
  146.                 editpmax++;
  147.             }
  148.             m=YES;
  149.             fmtadj(editbuf,kk,editpmax);
  150.         }
  151.     }
  152. /* end experimental code */
  153.     oldc=editbuf[editp];
  154.     editbuf[editp]=c;
  155.     fmtadj(editbuf,editp,editpmax);
  156.     k=fmtlen(editbuf,editpmax);
  157.     if (k>SCRNW1) {
  158.         editbuf[editp]=oldc;
  159.         fmtadj(editbuf,editp,editpmax);
  160.     }
  161.     else {
  162.         edcflag=YES;
  163.         editp++;
  164.         if ((c==TAB)|(oldc==TAB)) {
  165.         edredraw();
  166.         }
  167.         else {
  168.         fmtchdev(c);
  169.         }
  170.     }
  171. /* begin experimental code */
  172.     if ((m==YES)&(tabpos!=(tablength()-1))) {
  173.         k=editpmax;
  174.         while (k>editp) {
  175.             editbuf[k]=editbuf[k-1];
  176.             k--;
  177.         }
  178.         editbuf[editp]=TAB;
  179.         editpmax++;
  180.         fmtadj(editbuf,editp,editpmax);
  181.         edredraw();
  182.     }
  183. /* end experimental code */
  184. }
  185. edldel()   /* deletes character before cursor */
  186. /* eddel() in original version: no change in code */
  187. {
  188. int k;
  189.     if(edxpos() < outxget()) {
  190.         outxy(outxget()-1, outyget());
  191.         return;
  192.     }
  193.     if (editp==0) {
  194.         return;
  195.     }
  196.     edcflag=YES;
  197.     k=editp;
  198.     while (k<editpmax) {
  199.         editbuf[k-1]=editbuf[k];
  200.         k++;
  201.     }
  202.     editp--;
  203.     editpmax--;
  204.     edredraw();
  205. }
  206. edcdel()   /* deletes character at cursor */
  207. {
  208. int k;
  209.     if(edxpos() < outxget()) {
  210.         outxy(outxget()-1, outyget());
  211.         return;
  212.     }
  213.     edcflag=YES;
  214.     if (editp == editpmax)    {
  215.         if (editp==0) {
  216.             return;
  217.         }
  218.         editp--;
  219.         editpmax--;
  220.         edredraw();
  221.         return;
  222.     }
  223.     k=editp;
  224.     while (k<(editpmax-1)) {
  225.         editbuf[k]=editbuf[k+1];
  226.         k++;
  227.     }
  228.     editpmax--;
  229.     edredraw();
  230. }
  231. eddn()
  232. {
  233. int oldx;
  234.     oldx=outxget();
  235.     if (edrepl()!=OK) {
  236.         return(ERR);
  237.     }
  238.     if (bufnrbot()) {
  239.         sysabort();
  240.         return(OK);
  241.     }
  242.     if (bufdn()!=OK) {
  243.         return(ERR);
  244.     }
  245.     edgetln();
  246.     editp=edscan(oldx);
  247.     if (edatbot()) {
  248.         edsup(bufln()-SCRNL2);
  249.         outxy(oldx,SCRNL1);
  250.     }
  251.     else {
  252.         outxy(oldx,outyget()+1);
  253.     }
  254.     return(OK);
  255. }
  256. edend()
  257. {
  258.     editp=editpmax;
  259.     outxy(edxpos(),outyget());
  260. }
  261. edgo(n, p) int n, p;
  262. {
  263.     if (edrepl()==ERR) {
  264.         return(ERR);
  265.     }
  266.     if (bufgo(n)==ERR) {
  267.         return(ERR);
  268.     }
  269.     if (bufatbot()) {
  270.         if (bufup()==ERR) {
  271.             return(ERR);
  272.         }
  273.     }
  274.     bufout(bufln(),1,SCRNL1);
  275.     edgetln();
  276.     editp=min(p,editpmax);
  277.     outxy(edxpos(),1);
  278.     return(OK);
  279. }
  280. edins(c) char c;
  281. {
  282. int k,kk,n,l;
  283.     if (editpmax>=MAXLEN){
  284.         return;
  285.     }
  286.     if ((editp==editpmax) & (edxpos()<outxget())) {
  287.         k=outxget() - edxpos();
  288.         editpmax=editpmax+k;
  289.         while (k-- > 0) {
  290.             editbuf [editp++] = ' ';
  291.         }
  292.         editp=editpmax;
  293.     }
  294. /* experimental code for better treatment of virtual columns */
  295.     kk=editp-1;
  296.     if ((kk>=0)&(editbuf[kk]==TAB)&((l=outxget()%tablength())!=0)) {
  297.         editp--;
  298.         n=outxget()-edxpos();
  299.         if ((n+fmtlen(editbuf,editpmax)+1)<SCRNW1) {
  300.             k=editpmax;
  301.             while (k>(editp+1)) { 
  302.                 editbuf[k+n-1]=editbuf[k-1];
  303.                 k--;
  304.             }
  305.             while (n-- >0) {
  306.                 editbuf[editp++]=' ';
  307.                 editpmax++;
  308.             }
  309.             editbuf[editp]=c;
  310.             editp++;
  311.             if (l!=(tablength()-1)) {
  312.                 k=editpmax;
  313.                 while (k>editp) {
  314.                     editbuf[k]=editbuf[k-1];
  315.                     k--;
  316.                 }
  317.                 editbuf[editp]=TAB;
  318.                 editpmax++;
  319.             }
  320.             fmtadj(editbuf,kk,editpmax);
  321.             edredraw();
  322.             return;
  323.         }
  324.     }
  325. /* end experimental code */
  326.     k=editpmax;
  327.     while (k>editp) {
  328.         editbuf[k]=editbuf[k-1];
  329.         k--;
  330.     }
  331.     editbuf[editp]=c;
  332.     editp++;
  333.     editpmax++;
  334.     fmtadj(editbuf,editp-1,editpmax);
  335.     k=fmtlen(editbuf,editpmax);
  336.     if (k>SCRNW1) {
  337.         edldel();
  338.     }
  339.     else {
  340.         edcflag=YES;
  341.         edredraw();
  342.     }
  343. }
  344. edjoin()
  345. {
  346. int k;
  347.     if (bufattop()) {
  348.         return;
  349.     }
  350.     if (edrepl()!=OK) {
  351.         return;
  352.     }
  353.     if (bufup()!=OK) {
  354.         return;
  355.     }
  356.     k = bufgetln(editbuf,MAXLEN);
  357.     if (bufdn()!=OK) {
  358.         return;
  359.     }
  360.     k=k+bufgetln(editbuf+k,MAXLEN-k);
  361.     if (k>SCRNW1) {
  362.         bufgetln(editbuf,MAXLEN);
  363.         return;
  364.     }
  365.     if (bufup()!=OK) {
  366.         return;
  367.     }
  368.     editpmax=k;
  369.     edcflag=YES;
  370.     if (edrepl()!=OK) {
  371.         return;
  372.     }
  373.     if (bufdn()!=OK) {
  374.         return;
  375.     }
  376.     if (bufdel()!=OK) {
  377.         return;
  378.     }
  379.     if (bufup()!=OK) {
  380.         return;
  381.     }
  382.     if (edattop()) {
  383.         edredraw();
  384.     }
  385.     else {
  386.         k=outyget()-1;
  387.         bufout(bufln(),k,SCRNL-k);
  388.         outxy(0,k);
  389.         edredraw();
  390.     }
  391. }
  392. edkill(c) char c;
  393. {
  394. int k,p;
  395.     if (editp==editpmax) {
  396.         return;
  397.     }
  398.     edcflag=YES;
  399.     k=1;
  400.     while ((editp+k)<editpmax) {
  401.         if (editbuf[editp+k]==c){
  402.             break;
  403.         }
  404.         else {
  405.             k++;
  406.         }
  407.     }
  408.     p=editp+k;
  409.     while (p<editpmax) {
  410.         editbuf[p-k]=editbuf[p];
  411.         p++;
  412.     }
  413.     editpmax=editpmax-k;
  414.     edredraw();
  415. }
  416. edleft()
  417. {
  418. int k;
  419.     if (edxpos()<outxget()){
  420.         outxy(max(0,outxget()-1),outyget());
  421.     }
  422.     else if (editp!=0){
  423.         editp--;
  424.         outxy(edxpos(),outyget());
  425.     }
  426. }
  427. ednewdn()
  428. {
  429. int k;
  430.     if (bufatbot()){
  431.         if (bufins(editbuf,editpmax)!=OK){
  432.             return;
  433.         }
  434.     }
  435.     else if (edrepl()!=OK){
  436.             return;
  437.     }
  438.     if (bufdn()!=OK){
  439.         return;
  440.     }
  441.     if (bufins(editbuf,0)!=OK){
  442.         return;
  443.     }
  444.     edgetln();
  445.     if (edatbot()){
  446.         edsup(bufln()-SCRNL2);
  447.         outxy(edxpos(),SCRNL1);
  448.     }
  449.     else {
  450.         k=outyget();
  451.         bufout(bufln(),k+1,SCRNL1-k);
  452.         outxy(edxpos(),k+1);
  453.     }
  454. }
  455. ednewup()
  456. {
  457. int k;
  458.     if (edrepl()!=OK) {
  459.         return;
  460.     }
  461.     if (bufins(editbuf,0)!=OK){
  462.         return;
  463.     }
  464.     edgetln();
  465.     if (edattop()){
  466.         edsdn(bufln());
  467.         outxy(edxpos(),1);
  468.     }
  469.     else {
  470.         k=outyget();
  471.         bufout(bufln(),k,SCRNL-k);
  472.         outxy(edxpos(),k);
  473.     }
  474. }
  475. edright()    /* right one literal character - tabs move to next tab stop */
  476. {
  477.     if (edxpos()<outxget()){
  478.         outxy(min(SCRNW1,outxget()+1),outyget());
  479.     }
  480.     else if (edxpos()>outxget()){
  481.         outxy(edxpos(),outyget());
  482.     }
  483.     else if (editp<editpmax){
  484.         editp++;
  485.         outxy(edxpos(),outyget());
  486.     }
  487.     else {
  488.         outxy(min(SCRNW1,outxget()+1),outyget());
  489.     }
  490. }
  491. edsplit()
  492. {
  493. int p,q;
  494. int k;
  495.     edcflag = NO;
  496.     if (bufatbot()){
  497.         if (bufins(editbuf,editp)!=OK){
  498.             return;
  499.         }
  500.     }
  501.     else {
  502.         if (bufrepl(editbuf,editp)!=OK){
  503.             return;
  504.         }
  505.     }
  506.     p=editpmax;
  507.     q=editp;
  508.     editpmax=editp;
  509.     editp=0;
  510.     edredraw();
  511.     editp=0;
  512.     while (q<p){
  513.         editbuf[editp++] = editbuf[q++];
  514.     }
  515.     editpmax=editp;
  516.     editp=0;
  517.     if (bufdn()!=OK){
  518.         return;
  519.     }
  520.     if (bufins(editbuf,editpmax)!=OK) {
  521.         return;
  522.     }
  523.     if (edatbot()) {
  524.         edsup(bufln()-SCRNL2);
  525.         outxy(1,SCRNL1);
  526.         edredraw();
  527.     }
  528.     else {
  529.         k=outyget();
  530.         bufout(bufln(),k+1,SCRNL1-k);
  531.         outxy(1,k+1);
  532.         edredraw();
  533.     }
  534. }
  535. edsrch(c) char c;
  536. {
  537.     if (editp==editpmax){
  538.         return;
  539.     }
  540.     editp++;
  541.     while (editp<editpmax) {
  542.         if (editbuf[editp]==c) {
  543.             break;
  544.         }
  545.         else {
  546.             editp++;
  547.         }
  548.     }
  549.     outxy(edxpos(),outyget());
  550. }
  551. edabsright()  /* right one column - one virtual character */
  552. {
  553. int xpos;
  554.     xpos=outxget();
  555.     if (xpos<SCRNW1) {
  556.         outxy(++xpos,outyget());
  557.         editp=edscan(xpos);
  558.     }
  559. }
  560. edabsleft()   /* left one column - one virtual character */
  561. {
  562. int xpos;
  563.     xpos=outxget();
  564.     if (xpos>0) {
  565.         outxy(--xpos,outyget());
  566.         editp=edscan(xpos);
  567.     }
  568. }
  569. edup()
  570. {
  571. int oldx;
  572.     oldx=outxget();
  573.     if (edrepl()!=OK) {
  574.         return(ERR);
  575.     }
  576.     if (bufattop()) {
  577.         sysabort();
  578.         return(OK);
  579.     }
  580.     if (bufup()!=OK){
  581.         return(ERR);
  582.     }
  583.     edgetln();
  584.     editp=edscan(oldx);
  585.     if (edattop()) {
  586.         edsdn(bufln());
  587.         outxy(oldx,1);
  588.     }
  589.     else {
  590.         outxy(oldx,outyget()-1);
  591.     }
  592.     return(OK);
  593. }
  594. edzap()
  595. {
  596. int k;
  597.     if (bufdel()!=OK){
  598.         return;
  599.     }
  600.     if (bufatbot()){
  601.         if (bufup()!=OK){
  602.             return;
  603.         }
  604.         edgetln();
  605.         if (edattop()) {
  606.             edredraw();
  607.         }
  608.         else {
  609.             outdelln();
  610.             outxy(0,outyget()-1);
  611.         }
  612.         return;
  613.     }
  614.     edgetln();
  615.     if (edattop()) {
  616.         edsup (bufln());
  617.         outxy(0,1);
  618.     }
  619.     else {
  620.         k=outyget();
  621.         bufout(bufln(),k,SCRNL-k);
  622.         outxy(0,k);
  623.     }
  624. }
  625. edatbot()
  626. {
  627.     return(outyget()==SCRNL1);
  628. }
  629. edattop()
  630. {
  631.     return(outyget()==1);
  632. }
  633. edredraw()
  634. {
  635.     fmtadj(editbuf,0,editpmax);
  636.     fmtsubs(editbuf,max(0,editp-1),editpmax);
  637.     outxy(edxpos(),outyget());
  638. }
  639. edxpos()
  640. {
  641.     return(min(SCRNW1,fmtlen(editbuf,editp)));
  642. }
  643. edgetln()
  644. {
  645. int k;
  646.     editp=0;
  647.     edcflag=NO;
  648.     k=bufgetln(editbuf,MAXLEN);
  649.     if (k>MAXLEN) {
  650.         error("line truncated");
  651.         editpmax=MAXLEN;
  652.     }
  653.     else {
  654.         editpmax=k;
  655.     }
  656.     fmtadj(editbuf,0,editpmax);
  657. }
  658. edrepl()
  659. {
  660.     if (edcflag==NO) {
  661.         return(OK);
  662.     }
  663.     edcflag=NO;
  664.     if (bufatbot()){
  665.         return(bufins(editbuf,editpmax));
  666.     }
  667.     else {
  668.         return(bufrepl(editbuf,editpmax));
  669.     }
  670. }
  671. edscan(xpos) int xpos;
  672. {
  673.     editp=0;
  674.     while (editp<editpmax){
  675.         if (fmtlen(editbuf,editp)<xpos){
  676.             editp++;
  677.         }
  678.         else {
  679.             break;
  680.         }
  681.     }
  682.     return(editp);
  683. }
  684. edsup(topline) int topline;
  685. {
  686.     if (outuphas()==YES){
  687.         outsup();
  688.         bufout(topline+SCRNL2,SCRNL1,1);
  689.     }
  690.     else {
  691.         bufout(topline,1,SCRNL1);
  692.     }
  693. }
  694. edsdn(topline) int topline;
  695. {
  696.     if (outdnhas()==YES) {
  697.         outsdn();
  698.         bufout(topline,1,1);
  699.     }
  700.     else {
  701.         bufout(topline,1,SCRNL1);
  702.     }
  703. }
  704.